Package netscape.ldap.controls

Class LDAPVirtualListControl

java.lang.Object
netscape.ldap.LDAPControl
netscape.ldap.controls.LDAPVirtualListControl
All Implemented Interfaces:
Serializable, Cloneable
Direct Known Subclasses:
LdapVirtualListControl
public class LDAPVirtualListControl extends LDAPControl
Represents control data for returning paged results from a search. Example of usage, with JFC: 

  // Call this to initialize the list box, whenever the search
  // conditions change.
  // "filter" may be "objectclass=person", for example
  void initListBox( String host, int port, String base, String filter ) {

  // Create list box if not already done
   if ( _dataList == null ) {
       _dataList = new JList();
       JScrollPane scrollPane = new JScrollPane(_dataList);
       add( scrollPane );
   }

   // Create a virtual data model
   vlistModel model = new vlistModel( host, port, base, filter );
   // Keep a buffer of one page before and one after
   model.setPageSize( getScrollVisibleSize() );
   _dataList.setModel( model );
  }

  // Data model to supply buffer list data
  class vlistModel extends AbstractListModel {
  vlistModel( String host, int port, String base, String filter ) {
      _base = base;
      _filter = filter;

      // Connect to the server
      try {
          _ldc = new LDAPConnection();
          System.out.println( "Connecting to " + host +
                              ":" + port );
          _ldc.connect( host, port );
      } catch ( LDAPException e ) {
          System.out.println( e );
          _ldc = null;
      }
  }

  // Called by JList to get virtual list size
    public int getSize() {
      if ( !_initialized ) {
          _initialized = true;
          _pageControls = new LDAPControl[2];
          // Paged results also require a sort control
          _pageControls[0] =
              new LDAPSortControl( new LDAPSortKey("cn"),
                                   true );
          // Do an initial search to get the virtual list size
          // Keep one page before and one page after the start
          _beforeCount = _pageSize;
          _afterCount = _pageSize;
          // Create the initial paged results control
          LDAPVirtualListControl cont =
              new LDAPVirtualListControl( "A",
                                          _beforeCount,
                                          _afterCount );
          _pageControls[1] = cont;
          _vlc = (LDAPVirtualListControl)_pageControls[1];
          getPage( 0 );
      }
      return _size;
  }

  // Get a page starting at first (although we may also fetch
  // some preceding entries)
  boolean getPage( int first ) {
      _vlc.setRange( first, _beforeCount, _afterCount );
      return getPage();
  }

  boolean getEntries() {
      // Specify necessary controls for vlv
      if ( _pageControls != null ) {
          try {
              _ldc.setOption( _ldc.SERVERCONTROLS, _pageControls );
          } catch ( LDAPException e ) {
              System.out.println( e + ", setting vlv control" );
          }
      }
      // Empty the buffer
      _entries.removeAllElements();
      // Do a search
      try {
          String[] attrs = { "cn" };
          LDAPSearchResults result =
              _ldc.search( _base,
                           LDAPConnection.SCOPE_SUB,
                           _filter,
                           attrs, false );
          while ( result.hasMoreElements() ) {
              LDAPEntry entry = (LDAPEntry)result.nextElement();
              LDAPAttribute attr = entry.getAttribute( attrs[0] );
              if ( attr != null ) {
                  Enumeration en = attr.getStringValues();
                  while( en.hasMoreElements() ) {
                      String name = (String)en.nextElement();
                      _entries.addElement( name );
                  }
              }
          }
      } catch ( LDAPException e ) {
          System.out.println( e + ", searching" );
          return false;
      }
      return true;
  }

  // Fetch a buffer
  boolean getPage() {
      // Get the actual entries
      if ( !getEntries() )
          return false;

      // Check if we have a control returned
      LDAPControl[] c = _ldc.getResponseControls();
      LDAPVirtualListResponse nextCont = null;
      for ( int i = 0; i < c.length; i++ ) {
          if ( c[i] instanceof LDAPVirtualListResponse ) {
              nextCont = (LDAPVirtualListResponse)c[i];
              break;
          }
      }
      if ( nextCont != null ) {
          _selectedIndex = nextCont.getFirstPosition() - 1;
          _top = Math.max( 0, _selectedIndex - _beforeCount );
          // Now we know the total size of the virtual list box
          _size = nextCont.getContentCount();
          _vlc.setListSize( _size );
      } else {
          System.out.println( "Null response control" );
      }
      return true;
  }

  // Called by JList to fetch data to paint a single list item
    public Object getElementAt(int index) {
      if ( (index < _top) || (index >= _top + _entries.size()) ) {
          getPage( index );
      }
      int offset = index - _top;
      if ( (offset < 0) || (offset >= _entries.size()) )
          return new String( "No entry at " + index );
      else
          return _entries.elementAt( offset );
  }

  // Called by application to find out the virutal selected index
    public int getSelectedIndex() {
      return _selectedIndex;
  }

  // Called by application to find out the top of the buffer
    public int getFirstIndex() {
      return _top;
  }

  public void setPageSize( int size ) {
      _pageSize = size;
  }

  Vector _entries = new Vector();
  protected boolean _initialized = false;
  private int _top = 0;
  protected int _beforeCount;
  protected int _afterCount;
  private int _pageSize = 10;
  private int _selectedIndex = 0;
  protected LDAPControl[] _pageControls = null;
  protected LDAPVirtualListControl _vlc = null;
  protected int _size = -1;
  private String _base;
  private String _filter;
  private LDAPConnection _ldc;
  }
 

   VirtualListViewRequest ::= SEQUENCE {
            beforeCount    INTEGER (0 .. maxInt),
            afterCount     INTEGER (0 .. maxInt),
            CHOICE {
                byIndex [0] SEQUENCE {
                    index           INTEGER,
                    contentCount    INTEGER
                }
                byFilter [1] jumpTo    Substring
            },
            contextID     OCTET STRING OPTIONAL
  }
Version:
1.0
See Also:

  • Field Details

    • VIRTUALLIST

      public static final String VIRTUALLIST
      See Also:

    • TAG_BYINDEX

      private static final int TAG_BYINDEX
      See Also:

    • TAG_BYFILTER

      private static final int TAG_BYFILTER
      See Also:

    • m_beforeCount

      private int m_beforeCount

    • m_afterCount

      private int m_afterCount

    • m_listIndex

      private int m_listIndex

    • m_listSize

      private int m_listSize

    • m_context

      private String m_context

  • Constructor Details

    • LDAPVirtualListControl

      LDAPVirtualListControl()
      Blank constructor for internal use in LDAPVirtualListControl.
      See Also:

    • LDAPVirtualListControl

      public LDAPVirtualListControl(String jumpTo, int beforeCount, int afterCount)
      Constructs a new LDAPVirtualListControl object. Use this constructor on an initial search operation, specifying the first entry to be matched, or the initial part of it.
      Parameters:
      jumpTo - an LDAP search expression defining the result set
      beforeCount - the number of results before the top/center to return per page
      afterCount - the number of results after the top/center to return per page
      See Also:

    • LDAPVirtualListControl

      public LDAPVirtualListControl(String jumpTo, int beforeCount, int afterCount, String context)

    • LDAPVirtualListControl

      public LDAPVirtualListControl(int startIndex, int beforeCount, int afterCount, int contentCount)
      Constructs a new LDAPVirtualListControl object. Use this constructor on a subsquent search operation, after we know the size of the virtual list, to fetch a subset.
      Parameters:
      startIndex - the index into the virtual list of an entry to return
      beforeCount - the number of results before the top/center to return per page
      afterCount - the number of results after the top/center to return per page
      See Also:

    • LDAPVirtualListControl

      public LDAPVirtualListControl(int startIndex, int beforeCount, int afterCount, int contentCount, String context)

  • Method Details

    • setRange

      public void setRange(int startIndex, int beforeCount, int afterCount)
      Sets the starting index, and the number of entries before and after to return. Apply this method to a control returned from a previous search, to specify what result range to return on the next search.
      Parameters:
      startIndex - the index into the virtual list of an entry to return
      beforeCount - the number of results before startIndex to return per page
      afterCount - the number of results after startIndex to return per page
      See Also:

    • setRange

      public void setRange(String jumpTo, int beforeCount, int afterCount)
      Sets the search expression, and the number of entries before and after to return.
      Parameters:
      jumpTo - an LDAP search expression defining the result set return.
      beforeCount - the number of results before startIndex to return per page
      afterCount - the number of results after startIndex to return per page
      See Also:

    • getIndex

      public int getIndex()
      Gets the size of the virtual result set.
      Returns:
      the size of the virtual result set, or -1 if not known.

    • getListSize

      public int getListSize()
      Gets the size of the virtual result set.
      Returns:
      the size of the virtual result set, or -1 if not known.

    • setListSize

      public void setListSize(int listSize)
      Sets the size of the virtual result set.
      Parameters:
      listSize - the virtual result set size

    • getBeforeCount

      public int getBeforeCount()
      Gets the number of results before the top/center to return per page.
      Returns:
      the number of results before the top/center to return per page.

    • getAfterCount

      public int getAfterCount()
      Gets the number of results after the top/center to return per page.
      Returns:
      the number of results after the top/center to return per page.

    • getContext

      public String getContext()
      Gets the optional context cookie.
      Returns:
      the optional context cookie.

    • setContext

      public void setContext(String context)
      Sets the optional context cookie.
      Parameters:
      context - the optional context cookie

    • createPageSpecification

      private byte[] createPageSpecification(String subFilter, int beforeCount, int afterCount)
      Creates a "flattened" BER encoding of the requested page specifications and return it as a byte array.
      Parameters:
      subFilter - filter expression for generating the results
      beforeCount - number of entries before first match to return
      afterCount - number of entries after first match to return
      Returns:
      the byte array of encoded data.

    • createPageSpecification

      private byte[] createPageSpecification(int listIndex, int listSize, int beforeCount, int afterCount)
      Creates a "flattened" BER encoding of the requested page specifications and return it as a byte array.
      Parameters:
      listIndex - the center or starting entry to return
      listSize - the virtual list size
      beforeCount - number of entries before the first match to return
      afterCount - number of entries after the first match to return
      Returns:
      the byte array of encoded data.

    • toString

      public String toString()
      Description copied from class: LDAPControl
      Return a string representation of the control for debugging
      Overrides:
      toString in class LDAPControl
      Returns:
      a string representation of the control.